package com.kwan.xframe.util;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.media.MediaMetadataRetriever;
import android.util.Log;
import android.widget.Toast;

import com.kwan.xframe.BaseApplication;
import com.orhanobut.logger.Logger;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;


/**
 * 文件处理工具类
 * <p>
 * Created by Mr.Kwan on 2017-7-25.
 */

public class FileUtil {

	public static void copyAssets(Resources resources, String assetDir, String dir) {



		String[] files;
		try {
			// 获得Assets一共有几多文件
			files = resources.getAssets().list(assetDir);
		} catch (IOException e1) {
			return;
		}
		File mWorkingPath = new File(dir);
		// 如果文件路径不存在
		if (!mWorkingPath.exists()) {
			// 创建文件夹
			if (!mWorkingPath.mkdirs()) {
				// 文件夹创建不成功时调用
				//Toast.makeText(BaseApplication.getInstance(), new Cha("文件夹创建失败"), Toast.LENGTH_LONG).show();
				return;
			}
		}

		for (String fileName : files) {
			try {
				// 获得每个文件的名字
				//String fileName = file;
				// 根据路径判断是文件夹还是文件
				if (!fileName.contains(".")) {
					if (0 == assetDir.length()) {
						copyAssets(resources, fileName, dir + fileName + "/");
					} else {
						copyAssets(resources, assetDir + "/" + fileName, dir + "/"
								+ fileName + "/");
					}
					continue;
				}
				File outFile = new File(mWorkingPath, fileName);
				if (outFile.exists())
					outFile.delete();
				InputStream in;
				if (0 != assetDir.length())
					in = resources.getAssets().open(assetDir + "/" + fileName);
				else
					in = resources.getAssets().open(fileName);
				OutputStream out = new FileOutputStream(outFile);
				// Transfer bytes from in to out
				byte[] buf = new byte[1024];
				int len;
				while ((len = in.read(buf)) > 0) {
					out.write(buf, 0, len);
				}
				in.close();
				out.close();
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static final int VIDEO_TYPE_NETWORK = 1;
	public static final int VIDEO_TYPE_LOCAL = 2;

	//获取视频缩略图
	public static Bitmap createVideoThumbnail(String url, int type) {
		Bitmap bitmap = null;
		long duration;
		MediaMetadataRetriever retriever = new MediaMetadataRetriever();
		try {
			//将网络文件以及本地文件区分开来设置
			if (type == VIDEO_TYPE_NETWORK) {
				retriever.setDataSource(url, new HashMap<String, String>());
			} else if (type == VIDEO_TYPE_LOCAL) {
				retriever.setDataSource(url);
			}

			String strDuration = retriever.extractMetadata(android.media.MediaMetadataRetriever.METADATA_KEY_DURATION);
			duration = Long.valueOf(strDuration) / 2;
			bitmap = retriever.getFrameAtTime(duration, MediaMetadataRetriever.OPTION_CLOSEST_SYNC);

		} catch (IllegalArgumentException ex) {
			Log.e("kwan", ex.toString());
			Log.e("kwan", "获取视频缩略图失败");
		} finally {
			try {
				retriever.release();
			} catch (Exception ex) {
				Log.e("kwan", ex.toString());
				Log.e("kwan", "释放MediaMetadataRetriever资源失败");
			}
		}
		return bitmap;
	}

	public static File bitmapToFile(Bitmap bitmap, String path) {

		File file = new File(path);//将要保存图片的路径
		try {

			BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));
			bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos);
			bos.flush();
			bos.close();

		} catch (IOException e) {
			e.printStackTrace();
		}
		return file;
	}

	public static File createFile(File zipdir, File zipfile) {
		if (!zipdir.exists()) {
			boolean result = zipdir.mkdirs();
			Logger.d("TAG zipdir.mkdirs() = " + result);
		}
		if (!zipfile.exists()) {
			try {
				boolean result = zipfile.createNewFile();
				Logger.d("TAG  zipdir.createNewFile() = " + result);
			} catch (IOException e) {
				e.printStackTrace();
				Log.e("TAG", e.getMessage());
			}
		}
		return zipfile;
	}

	public static void deleteFile(File file) {

		if (file.exists()) { // 判断文件是否存在
			if (file.isFile()) { // 判断是否是文件
				file.delete(); // delete()方法 你应该知道 是删除的意思;
			} else if (file.isDirectory()) { // 否则如果它是一个目录
				File files[] = file.listFiles(); // 声明目录下所有的文件 files[];
				for (File file1 : files) { // 遍历目录下所有的文件
					deleteFile(file1); // 把每个文件 用这个方法进行迭代
				}
			}
			file.delete();
		} else {
			Log.e("kwan", "delete 文件不存在！");
		}
	}

	/**
	 * 递归删除目录下的所有文件及子目录下所有文件
	 *
	 * @param dir 将要删除的文件目录
	 * @return 删除成功返回true，否则返回false
	 */
	public static boolean deleteDir(File dir) {
		if (dir.isDirectory()) {
			String[] children = dir.list();
			// 递归删除目录中的子目录下
			for (String aChildren : children) {
				boolean success = deleteDir(new File(dir, aChildren));
				if (!success) {
					return false;
				}
			}
		}
		// 目录此时为空，可以删除
		return dir.delete();
	}

	/**
	 * 获取文件夹的大小
	 *
	 * @param directory 需要测量大小的文件夹
	 * @return 返回文件夹大小，单位byte
	 */
	public static long folderSize(File directory) {
		long length = 0;
		for (File file : directory.listFiles()) {
			if (file.isFile())
				length += file.length();
			else
				length += folderSize(file);
		}
		return length;
	}

	/**
	 * 读取File中的内容
	 *
	 * @param file 请务必保证file文件已经存在
	 * @return file中的内容
	 */
	public static String getText(File file) {
		if (!file.exists()) {
			return null;
		}
		StringBuilder text = new StringBuilder();
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader(file));
			String line;
			while ((line = br.readLine()) != null) {
				text.append(line);
				text.append('\n');
			}

		} catch (IOException e) {
			Logger.e(e.toString());
			e.printStackTrace();
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return text.toString();
	}


	/**
	 * 遍历获取Log文件夹下的所有crash文件
	 *
	 * @param logdir 从哪个文件夹下找起
	 * @return 返回crash文件列表
	 */
	public static ArrayList<File> getCrashList(File logdir) {
		ArrayList<File> crashFileList = new ArrayList<>();
		findFiles(logdir.getAbsolutePath(), crashFileList);
		return crashFileList;
	}


	/**
	 * 将指定文件夹中满足要求的文件存储到list集合中
	 *
	 * @param f
	 * @param list
	 */

	/**
	 * 递归查找文件
	 *
	 * @param baseDirName 查找的文件夹路径
	 * @param fileList    查找到的文件集合
	 */
	public static void findFiles(String baseDirName, List<File> fileList) {
		File baseDir = new File(baseDirName);       // 创建一个File对象
		if (!baseDir.exists() || !baseDir.isDirectory()) {  // 判断目录是否存在
			Logger.e("文件查找失败：" + baseDirName + "不是一个目录！");
		}
		String tempName;
		//判断目录是否存在
		File tempFile;
		File[] files = baseDir.listFiles();
		for (File file : files) {
			tempFile = file;
			if (tempFile.isDirectory()) {
				findFiles(tempFile.getAbsolutePath(), fileList);
			} else if (tempFile.isFile()) {
				tempName = tempFile.getName();
				if (tempName.contains("Crash")) {
					// 匹配成功，将文件名添加到结果集
					fileList.add(tempFile.getAbsoluteFile());
				}
			}
		}
	}


	/**
	 * 解压assets目录下的zip到指定的路径
	 *
	 * @param zipFileString ZIP的名称，压缩包的名称：xxx.zip
	 * @param outPathString 要解压缩路径
	 */
	public static void UnZipAssetsFolder(Context context, String zipFileString, String outPathString) {

		try {
			ZipInputStream inZip = new ZipInputStream(context.getAssets().open(zipFileString));
			ZipEntry zipEntry;
			String szName = "";
			while ((zipEntry = inZip.getNextEntry()) != null) {
				szName = zipEntry.getName();
				if (zipEntry.isDirectory()) {
					//获取部件的文件夹名
					szName = szName.substring(0, szName.length() - 1);
					File folder = new File(outPathString + File.separator + szName);
					folder.mkdirs();
				} else {
					Log.e("kwan", outPathString + File.separator + szName);
					File file = new File(outPathString + File.separator + szName);
					if (!file.exists()) {
						Log.e("kwan", "Create the file:" + outPathString + File.separator + szName);
						file.getParentFile().mkdirs();
						file.createNewFile();
					}
					// 获取文件的输出流
					FileOutputStream out = new FileOutputStream(file);
					int len;
					byte[] buffer = new byte[1024];
					// 读取（字节）字节到缓冲区
					while ((len = inZip.read(buffer)) != -1) {
						// 从缓冲区（0）位置写入（字节）字节
						out.write(buffer, 0, len);
						out.flush();
					}
					out.close();
				}
			}
			inZip.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}


}
